home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / controls / Menu.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  46.3 KB  |  1,302 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.events.Event;
  6.    import flash.events.FocusEvent;
  7.    import flash.events.KeyboardEvent;
  8.    import flash.events.MouseEvent;
  9.    import flash.geom.Point;
  10.    import flash.geom.Rectangle;
  11.    import flash.ui.Keyboard;
  12.    import flash.utils.clearInterval;
  13.    import flash.utils.setTimeout;
  14.    import flash.xml.XMLNode;
  15.    import mx.collections.ArrayCollection;
  16.    import mx.collections.CursorBookmark;
  17.    import mx.collections.ICollectionView;
  18.    import mx.collections.XMLListCollection;
  19.    import mx.controls.listClasses.BaseListData;
  20.    import mx.controls.listClasses.IListItemRenderer;
  21.    import mx.controls.menuClasses.IMenuBarItemRenderer;
  22.    import mx.controls.menuClasses.IMenuDataDescriptor;
  23.    import mx.controls.menuClasses.IMenuItemRenderer;
  24.    import mx.controls.menuClasses.MenuItemRenderer;
  25.    import mx.controls.menuClasses.MenuListData;
  26.    import mx.controls.treeClasses.DefaultDataDescriptor;
  27.    import mx.core.Application;
  28.    import mx.core.ClassFactory;
  29.    import mx.core.EdgeMetrics;
  30.    import mx.core.EventPriority;
  31.    import mx.core.ScrollPolicy;
  32.    import mx.core.UIComponent;
  33.    import mx.core.UIComponentGlobals;
  34.    import mx.core.mx_internal;
  35.    import mx.effects.Tween;
  36.    import mx.events.CollectionEvent;
  37.    import mx.events.CollectionEventKind;
  38.    import mx.events.FlexEvent;
  39.    import mx.events.InterManagerRequest;
  40.    import mx.events.ListEvent;
  41.    import mx.events.MenuEvent;
  42.    import mx.events.SandboxMouseEvent;
  43.    import mx.managers.IFocusManagerContainer;
  44.    import mx.managers.ISystemManager;
  45.    import mx.managers.PopUpManager;
  46.    
  47.    use namespace mx_internal;
  48.    
  49.    public class Menu extends List implements IFocusManagerContainer
  50.    {
  51.       mx_internal static var createAccessibilityImplementation:Function;
  52.       
  53.       mx_internal static const VERSION:String = "3.2.0.3958";
  54.       
  55.       mx_internal var parentDisplayObject:DisplayObject;
  56.       
  57.       mx_internal var popupTween:Tween;
  58.       
  59.       mx_internal var closeTimer:int = 0;
  60.       
  61.       mx_internal var openSubMenuTimer:int = 0;
  62.       
  63.       mx_internal var showRootChanged:Boolean = false;
  64.       
  65.       mx_internal var sourceMenuBarItem:IMenuBarItemRenderer;
  66.       
  67.       mx_internal var _hasRoot:Boolean = false;
  68.       
  69.       mx_internal var dataProviderChanged:Boolean = false;
  70.       
  71.       private var maxMeasuredTypeIconWidth:Number = 0;
  72.       
  73.       mx_internal var sourceMenuBar:MenuBar;
  74.       
  75.       private var maxMeasuredBranchIconWidth:Number = 0;
  76.       
  77.       private var maxMeasuredIconWidth:Number = 0;
  78.       
  79.       private var subMenu:Menu;
  80.       
  81.       mx_internal var _parentMenu:Menu;
  82.       
  83.       private var useTwoColumns:Boolean = false;
  84.       
  85.       private var hiddenItem:IListItemRenderer;
  86.       
  87.       mx_internal var _showRoot:Boolean = true;
  88.       
  89.       mx_internal var _dataDescriptor:IMenuDataDescriptor;
  90.       
  91.       mx_internal var supposedToLoseFocus:Boolean = false;
  92.       
  93.       private var anchorRow:IListItemRenderer;
  94.       
  95.       mx_internal var _rootModel:ICollectionView;
  96.       
  97.       public function Menu()
  98.       {
  99.          mx_internal::_dataDescriptor = new DefaultDataDescriptor();
  100.          super();
  101.          itemRenderer = new ClassFactory(MenuItemRenderer);
  102.          setRowHeight(19);
  103.          iconField = "icon";
  104.          visible = false;
  105.       }
  106.       
  107.       private static function menuHideHandler(param1:MenuEvent) : void
  108.       {
  109.          var _loc2_:Menu = Menu(param1.target);
  110.          if(!param1.isDefaultPrevented() && param1.menu == _loc2_)
  111.          {
  112.             PopUpManager.removePopUp(_loc2_);
  113.             _loc2_.removeEventListener(MenuEvent.MENU_HIDE,menuHideHandler);
  114.          }
  115.       }
  116.       
  117.       public static function popUpMenu(param1:Menu, param2:DisplayObjectContainer, param3:Object) : void
  118.       {
  119.          param1.mx_internal::parentDisplayObject = !!param2 ? param2 : DisplayObject(Application.application);
  120.          if(!param3)
  121.          {
  122.             param3 = new XML();
  123.          }
  124.          param1.mx_internal::supposedToLoseFocus = true;
  125.          param1.dataProvider = param3;
  126.       }
  127.       
  128.       public static function createMenu(param1:DisplayObjectContainer, param2:Object, param3:Boolean = true) : Menu
  129.       {
  130.          var _loc4_:Menu = new Menu();
  131.          _loc4_.tabEnabled = false;
  132.          _loc4_.owner = DisplayObjectContainer(Application.application);
  133.          _loc4_.showRoot = param3;
  134.          popUpMenu(_loc4_,param1,param2);
  135.          return _loc4_;
  136.       }
  137.       
  138.       private function moveSelBy(param1:Number, param2:Number) : void
  139.       {
  140.          var _loc6_:Object = null;
  141.          var _loc8_:MenuEvent = null;
  142.          var _loc9_:Object = null;
  143.          var _loc3_:Number = param1;
  144.          if(isNaN(_loc3_))
  145.          {
  146.             _loc3_ = -1;
  147.          }
  148.          var _loc4_:Number = Math.max(0,Math.min(rowCount,collection.length) - 1);
  149.          var _loc5_:Number = _loc3_;
  150.          var _loc7_:int = 0;
  151.          while(true)
  152.          {
  153.             _loc5_ += param2;
  154.             if(_loc7_ > _loc4_)
  155.             {
  156.                break;
  157.             }
  158.             _loc7_++;
  159.             if(_loc5_ > _loc4_)
  160.             {
  161.                _loc5_ = 0;
  162.             }
  163.             else if(_loc5_ < 0)
  164.             {
  165.                _loc5_ = _loc4_;
  166.             }
  167.             _loc6_ = listItems[_loc5_][0];
  168.             if(!(Boolean(_loc6_.data) && (mx_internal::_dataDescriptor.getType(_loc6_.data) == "separator" || !mx_internal::_dataDescriptor.isEnabled(_loc6_.data))))
  169.             {
  170.                if(selectedIndex != -1)
  171.                {
  172.                   _loc9_ = listItems[selectedIndex][0];
  173.                   _loc8_ = new MenuEvent(MenuEvent.ITEM_ROLL_OUT);
  174.                   _loc8_.menu = this;
  175.                   _loc8_.index = this.selectedIndex;
  176.                   _loc8_.menuBar = mx_internal::sourceMenuBar;
  177.                   _loc8_.label = itemToLabel(_loc9_.data);
  178.                   _loc8_.item = _loc9_.data;
  179.                   _loc8_.itemRenderer = IListItemRenderer(_loc9_);
  180.                   mx_internal::getRootMenu().dispatchEvent(_loc8_);
  181.                }
  182.                if(_loc6_.data)
  183.                {
  184.                   selectItem(listItems[_loc5_ - verticalScrollPosition][0],false,false);
  185.                   _loc8_ = new MenuEvent(MenuEvent.ITEM_ROLL_OVER);
  186.                   _loc8_.menu = this;
  187.                   _loc8_.index = this.selectedIndex;
  188.                   _loc8_.menuBar = mx_internal::sourceMenuBar;
  189.                   _loc8_.label = itemToLabel(_loc6_.data);
  190.                   _loc8_.item = _loc6_.data;
  191.                   _loc8_.itemRenderer = IListItemRenderer(_loc6_);
  192.                   mx_internal::getRootMenu().dispatchEvent(_loc8_);
  193.                }
  194.                return;
  195.             }
  196.          }
  197.       }
  198.       
  199.       override public function measureWidthOfItems(param1:int = -1, param2:int = 0) : Number
  200.       {
  201.          var _loc6_:CursorBookmark = null;
  202.          var _loc7_:int = 0;
  203.          var _loc8_:int = 0;
  204.          var _loc9_:Boolean = false;
  205.          var _loc10_:Object = null;
  206.          var _loc11_:MenuListData = null;
  207.          var _loc12_:IListItemRenderer = null;
  208.          var _loc13_:IMenuItemRenderer = null;
  209.          var _loc3_:Number = 0;
  210.          var _loc4_:Number = getStyle("leftIconGap");
  211.          var _loc5_:Number = getStyle("rightIconGap");
  212.          maxMeasuredIconWidth = 0;
  213.          maxMeasuredTypeIconWidth = 0;
  214.          maxMeasuredBranchIconWidth = 0;
  215.          useTwoColumns = false;
  216.          if(Boolean(collection) && Boolean(collection.length))
  217.          {
  218.             _loc6_ = iterator.bookmark;
  219.             _loc7_ = param2;
  220.             _loc8_ = 0;
  221.             while(_loc8_ < 2)
  222.             {
  223.                iterator.seek(CursorBookmark.FIRST,param1);
  224.                param2 = _loc7_;
  225.                _loc9_ = false;
  226.                while(param2)
  227.                {
  228.                   _loc10_ = iterator.current;
  229.                   _loc12_ = hiddenItem = mx_internal::getMeasuringRenderer(_loc10_);
  230.                   _loc12_.explicitWidth = NaN;
  231.                   mx_internal::setupRendererFromData(_loc12_,_loc10_);
  232.                   _loc3_ = Math.max(_loc12_.getExplicitOrMeasuredWidth(),_loc3_);
  233.                   if(_loc12_ is IMenuItemRenderer)
  234.                   {
  235.                      _loc13_ = IMenuItemRenderer(_loc12_);
  236.                      if(_loc13_.measuredIconWidth > maxMeasuredIconWidth)
  237.                      {
  238.                         maxMeasuredIconWidth = _loc13_.measuredIconWidth;
  239.                         _loc9_ = true;
  240.                      }
  241.                      if(_loc13_.measuredTypeIconWidth > maxMeasuredTypeIconWidth)
  242.                      {
  243.                         maxMeasuredTypeIconWidth = _loc13_.measuredTypeIconWidth;
  244.                         _loc9_ = true;
  245.                      }
  246.                      if(_loc13_.measuredBranchIconWidth > maxMeasuredBranchIconWidth)
  247.                      {
  248.                         maxMeasuredBranchIconWidth = _loc13_.measuredBranchIconWidth;
  249.                         _loc9_ = true;
  250.                      }
  251.                      if(_loc13_.measuredIconWidth > 0 && Boolean(_loc13_.measuredTypeIconWidth))
  252.                      {
  253.                         useTwoColumns = true;
  254.                         _loc9_ = true;
  255.                      }
  256.                   }
  257.                   param2--;
  258.                   if(!iterator.moveNext())
  259.                   {
  260.                      break;
  261.                   }
  262.                }
  263.                if(_loc8_ == 0)
  264.                {
  265.                   if(!(_loc9_ && (maxMeasuredIconWidth + maxMeasuredTypeIconWidth > _loc4_ || maxMeasuredBranchIconWidth > _loc5_)))
  266.                   {
  267.                      break;
  268.                   }
  269.                }
  270.                _loc8_++;
  271.             }
  272.             iterator.seek(_loc6_,0);
  273.          }
  274.          if(!_loc3_)
  275.          {
  276.             _loc3_ = 200;
  277.          }
  278.          return _loc3_ + (getStyle("paddingLeft") + getStyle("paddingRight"));
  279.       }
  280.       
  281.       override protected function mouseUpHandler(param1:MouseEvent) : void
  282.       {
  283.          var _loc2_:MenuEvent = null;
  284.          var _loc4_:Object = null;
  285.          var _loc5_:Boolean = false;
  286.          if(!enabled || !selectable || !visible)
  287.          {
  288.             return;
  289.          }
  290.          super.mouseUpHandler(param1);
  291.          var _loc3_:IListItemRenderer = mouseEventToItemRenderer(param1);
  292.          if(Boolean(_loc3_) && Boolean(_loc3_.data))
  293.          {
  294.             _loc4_ = _loc3_.data;
  295.          }
  296.          if(_loc4_ != null && mx_internal::_dataDescriptor.isEnabled(_loc4_) && !mx_internal::_dataDescriptor.isBranch(_loc4_))
  297.          {
  298.             _loc5_ = mx_internal::_dataDescriptor.getType(_loc4_) != "radio" || !mx_internal::_dataDescriptor.isToggled(_loc4_);
  299.             if(_loc5_)
  300.             {
  301.                setMenuItemToggled(_loc4_,!mx_internal::_dataDescriptor.isToggled(_loc4_));
  302.             }
  303.             _loc2_ = new MenuEvent(MenuEvent.ITEM_CLICK);
  304.             _loc2_.menu = this;
  305.             _loc2_.index = this.selectedIndex;
  306.             _loc2_.menuBar = mx_internal::sourceMenuBar;
  307.             _loc2_.label = itemToLabel(_loc4_);
  308.             _loc2_.item = _loc4_;
  309.             _loc2_.itemRenderer = _loc3_;
  310.             mx_internal::getRootMenu().dispatchEvent(_loc2_);
  311.             if(_loc5_)
  312.             {
  313.                _loc2_ = new MenuEvent(MenuEvent.CHANGE);
  314.                _loc2_.menu = this;
  315.                _loc2_.index = this.selectedIndex;
  316.                _loc2_.menuBar = mx_internal::sourceMenuBar;
  317.                _loc2_.label = itemToLabel(_loc4_);
  318.                _loc2_.item = _loc4_;
  319.                _loc2_.itemRenderer = _loc3_;
  320.                mx_internal::getRootMenu().dispatchEvent(_loc2_);
  321.             }
  322.             mx_internal::hideAllMenus();
  323.          }
  324.       }
  325.       
  326.       private function isMouseOverMenu(param1:MouseEvent) : Boolean
  327.       {
  328.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  329.          while(_loc2_)
  330.          {
  331.             if(_loc2_ is Menu)
  332.             {
  333.                return true;
  334.             }
  335.             _loc2_ = _loc2_.parent;
  336.          }
  337.          return false;
  338.       }
  339.       
  340.       override protected function focusOutHandler(param1:FocusEvent) : void
  341.       {
  342.          super.focusOutHandler(param1);
  343.          if(!mx_internal::supposedToLoseFocus)
  344.          {
  345.             mx_internal::hideAllMenus();
  346.          }
  347.          mx_internal::supposedToLoseFocus = false;
  348.       }
  349.       
  350.       mx_internal function openSubMenu(param1:IListItemRenderer) : void
  351.       {
  352.          var _loc3_:Menu = null;
  353.          mx_internal::supposedToLoseFocus = true;
  354.          var _loc2_:Menu = mx_internal::getRootMenu();
  355.          if(!IMenuItemRenderer(param1).menu)
  356.          {
  357.             _loc3_ = new Menu();
  358.             _loc3_.parentMenu = this;
  359.             _loc3_.owner = this;
  360.             _loc3_.showRoot = showRoot;
  361.             _loc3_.dataDescriptor = _loc2_.dataDescriptor;
  362.             _loc3_.styleName = _loc2_;
  363.             _loc3_.labelField = _loc2_.labelField;
  364.             _loc3_.labelFunction = _loc2_.labelFunction;
  365.             _loc3_.iconField = _loc2_.iconField;
  366.             _loc3_.iconFunction = _loc2_.iconFunction;
  367.             _loc3_.itemRenderer = _loc2_.itemRenderer;
  368.             _loc3_.rowHeight = _loc2_.rowHeight;
  369.             _loc3_.scaleY = _loc2_.scaleY;
  370.             _loc3_.scaleX = _loc2_.scaleX;
  371.             if(param1.data && mx_internal::_dataDescriptor.isBranch(param1.data) && mx_internal::_dataDescriptor.hasChildren(param1.data))
  372.             {
  373.                _loc3_.dataProvider = mx_internal::_dataDescriptor.getChildren(param1.data);
  374.             }
  375.             _loc3_.mx_internal::sourceMenuBar = mx_internal::sourceMenuBar;
  376.             _loc3_.mx_internal::sourceMenuBarItem = mx_internal::sourceMenuBarItem;
  377.             IMenuItemRenderer(param1).menu = _loc3_;
  378.             PopUpManager.addPopUp(_loc3_,_loc2_,false);
  379.          }
  380.          else
  381.          {
  382.             _loc3_ = IMenuItemRenderer(param1).menu;
  383.          }
  384.          var _loc4_:DisplayObject = DisplayObject(param1);
  385.          var _loc5_:Point = new Point(0,0);
  386.          _loc5_ = _loc4_.localToGlobal(_loc5_);
  387.          if(_loc4_.root)
  388.          {
  389.             _loc5_ = _loc4_.root.globalToLocal(_loc5_);
  390.          }
  391.          _loc3_.show(_loc5_.x + param1.width,_loc5_.y);
  392.          subMenu = _loc3_;
  393.          clearInterval(mx_internal::openSubMenuTimer);
  394.          mx_internal::openSubMenuTimer = 0;
  395.       }
  396.       
  397.       public function get parentMenu() : Menu
  398.       {
  399.          return mx_internal::_parentMenu;
  400.       }
  401.       
  402.       private function parentRowHeightHandler(param1:Event) : void
  403.       {
  404.          rowHeight = parentMenu.rowHeight;
  405.       }
  406.       
  407.       mx_internal function hideAllMenus() : void
  408.       {
  409.          mx_internal::getRootMenu().hide();
  410.          mx_internal::getRootMenu().mx_internal::deleteDependentSubMenus();
  411.       }
  412.       
  413.       override public function dispatchEvent(param1:Event) : Boolean
  414.       {
  415.          var _loc2_:MenuEvent = null;
  416.          if(!(param1 is MenuEvent) && param1 is ListEvent && (param1.type == ListEvent.ITEM_ROLL_OUT || param1.type == ListEvent.ITEM_ROLL_OVER || param1.type == ListEvent.CHANGE))
  417.          {
  418.             param1.stopImmediatePropagation();
  419.          }
  420.          if(!(param1 is MenuEvent) && param1 is ListEvent && param1.type == ListEvent.ITEM_CLICK)
  421.          {
  422.             _loc2_ = new MenuEvent(param1.type,param1.bubbles,param1.cancelable);
  423.             _loc2_.item = ListEvent(param1).itemRenderer.data;
  424.             _loc2_.label = itemToLabel(ListEvent(param1).itemRenderer);
  425.             return super.dispatchEvent(_loc2_);
  426.          }
  427.          return super.dispatchEvent(param1);
  428.       }
  429.       
  430.       mx_internal function deleteDependentSubMenus() : void
  431.       {
  432.          var _loc3_:Menu = null;
  433.          var _loc1_:int = int(listItems.length);
  434.          var _loc2_:int = 0;
  435.          while(_loc2_ < _loc1_)
  436.          {
  437.             if(listItems[_loc2_][0])
  438.             {
  439.                _loc3_ = IMenuItemRenderer(listItems[_loc2_][0]).menu;
  440.                if(_loc3_)
  441.                {
  442.                   _loc3_.mx_internal::deleteDependentSubMenus();
  443.                   PopUpManager.removePopUp(_loc3_);
  444.                   IMenuItemRenderer(listItems[_loc2_][0]).menu = null;
  445.                }
  446.             }
  447.             _loc2_++;
  448.          }
  449.       }
  450.       
  451.       public function hide() : void
  452.       {
  453.          var _loc1_:DisplayObject = null;
  454.          var _loc2_:MenuEvent = null;
  455.          if(visible)
  456.          {
  457.             if(mx_internal::popupTween)
  458.             {
  459.                mx_internal::popupTween.endTween();
  460.             }
  461.             clearSelected();
  462.             if(anchorRow)
  463.             {
  464.                drawItem(anchorRow,false,false);
  465.                anchorRow = null;
  466.             }
  467.             visible = false;
  468.             _loc1_ = systemManager.getSandboxRoot();
  469.             _loc1_.removeEventListener(MouseEvent.MOUSE_DOWN,mouseDownOutsideHandler);
  470.             removeEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,mouseDownOutsideHandler);
  471.             _loc2_ = new MenuEvent(MenuEvent.MENU_HIDE);
  472.             _loc2_.menu = this;
  473.             _loc2_.menuBar = mx_internal::sourceMenuBar;
  474.             mx_internal::getRootMenu().dispatchEvent(_loc2_);
  475.          }
  476.       }
  477.       
  478.       override public function set horizontalScrollPolicy(param1:String) : void
  479.       {
  480.       }
  481.       
  482.       public function set parentMenu(param1:Menu) : void
  483.       {
  484.          mx_internal::_parentMenu = param1;
  485.          param1.addEventListener(FlexEvent.HIDE,parentHideHandler,false,0,true);
  486.          param1.addEventListener("rowHeightChanged",parentRowHeightHandler,false,0,true);
  487.          param1.addEventListener("iconFieldChanged",parentIconFieldHandler,false,0,true);
  488.          param1.addEventListener("iconFunctionChanged",parentIconFunctionHandler,false,0,true);
  489.          param1.addEventListener("labelFieldChanged",parentLabelFieldHandler,false,0,true);
  490.          param1.addEventListener("labelFunctionChanged",parentLabelFunctionHandler,false,0,true);
  491.          param1.addEventListener("itemRendererChanged",parentItemRendererHandler,false,0,true);
  492.       }
  493.       
  494.       protected function setMenuItemToggled(param1:Object, param2:Boolean) : void
  495.       {
  496.          var _loc3_:String = null;
  497.          var _loc4_:int = 0;
  498.          var _loc5_:IListItemRenderer = null;
  499.          var _loc6_:Object = null;
  500.          itemsSizeChanged = true;
  501.          invalidateDisplayList();
  502.          if(mx_internal::_dataDescriptor.getType(param1) == "radio")
  503.          {
  504.             _loc3_ = mx_internal::_dataDescriptor.getGroupName(param1);
  505.             _loc4_ = 0;
  506.             while(_loc4_ < listItems.length)
  507.             {
  508.                _loc5_ = listItems[_loc4_][0];
  509.                _loc6_ = _loc5_.data;
  510.                if(mx_internal::_dataDescriptor.getType(_loc6_) == "radio" && mx_internal::_dataDescriptor.getGroupName(_loc6_) == _loc3_)
  511.                {
  512.                   mx_internal::_dataDescriptor.setToggled(_loc6_,_loc6_ == param1);
  513.                }
  514.                _loc4_++;
  515.             }
  516.          }
  517.          if(param2 != mx_internal::_dataDescriptor.isToggled(param1))
  518.          {
  519.             mx_internal::_dataDescriptor.setToggled(param1,param2);
  520.          }
  521.       }
  522.       
  523.       override protected function measure() : void
  524.       {
  525.          var _loc1_:EdgeMetrics = null;
  526.          var _loc2_:int = 0;
  527.          super.measure();
  528.          if(!dataProvider || dataProvider.length == 0)
  529.          {
  530.             measuredWidth = 0;
  531.             measuredHeight = 0;
  532.          }
  533.          else
  534.          {
  535.             _loc1_ = viewMetrics;
  536.             measuredMinWidth = measuredWidth = measureWidthOfItems(0,dataProvider.length);
  537.             if(variableRowHeight)
  538.             {
  539.                _loc2_ = measureHeightOfItems(0,dataProvider.length);
  540.             }
  541.             else
  542.             {
  543.                _loc2_ = dataProvider.length * rowHeight;
  544.             }
  545.             measuredMinHeight = measuredHeight = _loc2_ + _loc1_.top + _loc1_.bottom;
  546.          }
  547.       }
  548.       
  549.       override protected function mouseDownHandler(param1:MouseEvent) : void
  550.       {
  551.          var _loc3_:Object = null;
  552.          var _loc2_:IListItemRenderer = mouseEventToItemRenderer(param1);
  553.          if(Boolean(_loc2_) && Boolean(_loc2_.data))
  554.          {
  555.             _loc3_ = _loc2_.data;
  556.          }
  557.          if(_loc3_ && mx_internal::_dataDescriptor.isEnabled(_loc3_) && !mx_internal::_dataDescriptor.isBranch(_loc3_))
  558.          {
  559.             super.mouseDownHandler(param1);
  560.          }
  561.       }
  562.       
  563.       override protected function mouseEventToItemRenderer(param1:MouseEvent) : IListItemRenderer
  564.       {
  565.          var _loc2_:IListItemRenderer = super.mouseEventToItemRenderer(param1);
  566.          if(_loc2_ && _loc2_.data && mx_internal::_dataDescriptor.getType(_loc2_.data) == "separator")
  567.          {
  568.             return null;
  569.          }
  570.          return _loc2_;
  571.       }
  572.       
  573.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  574.       {
  575.          var _loc5_:MenuEvent = null;
  576.          var _loc2_:IListItemRenderer = selectedIndex == -1 ? null : listItems[selectedIndex - verticalScrollPosition][0];
  577.          var _loc3_:Object = !!_loc2_ ? _loc2_.data : null;
  578.          var _loc4_:Menu = !!_loc2_ ? IMenuItemRenderer(_loc2_).menu : null;
  579.          if(param1.keyCode == Keyboard.UP)
  580.          {
  581.             if(_loc3_ && mx_internal::_dataDescriptor.isBranch(_loc3_) && _loc4_ && _loc4_.visible)
  582.             {
  583.                mx_internal::supposedToLoseFocus = true;
  584.                _loc4_.setFocus();
  585.                _loc4_.moveSelBy(_loc4_.dataProvider.length,-1);
  586.             }
  587.             else
  588.             {
  589.                moveSelBy(selectedIndex,-1);
  590.             }
  591.             param1.stopPropagation();
  592.          }
  593.          else if(param1.keyCode == Keyboard.DOWN)
  594.          {
  595.             if(_loc3_ && mx_internal::_dataDescriptor.isBranch(_loc3_) && _loc4_ && _loc4_.visible)
  596.             {
  597.                mx_internal::supposedToLoseFocus = true;
  598.                _loc4_.setFocus();
  599.                _loc4_.moveSelBy(-1,1);
  600.             }
  601.             else
  602.             {
  603.                moveSelBy(selectedIndex,1);
  604.             }
  605.             param1.stopPropagation();
  606.          }
  607.          else if(param1.keyCode == Keyboard.RIGHT)
  608.          {
  609.             if(Boolean(_loc3_) && mx_internal::_dataDescriptor.isBranch(_loc3_))
  610.             {
  611.                mx_internal::openSubMenu(_loc2_);
  612.                _loc4_ = IMenuItemRenderer(_loc2_).menu;
  613.                mx_internal::supposedToLoseFocus = true;
  614.                _loc4_.setFocus();
  615.                _loc4_.moveSelBy(-1,1);
  616.             }
  617.             else if(mx_internal::sourceMenuBar)
  618.             {
  619.                mx_internal::supposedToLoseFocus = true;
  620.                mx_internal::sourceMenuBar.setFocus();
  621.                mx_internal::sourceMenuBar.dispatchEvent(param1);
  622.             }
  623.             param1.stopPropagation();
  624.          }
  625.          else if(param1.keyCode == Keyboard.LEFT)
  626.          {
  627.             if(mx_internal::_parentMenu)
  628.             {
  629.                mx_internal::supposedToLoseFocus = true;
  630.                hide();
  631.                mx_internal::_parentMenu.setFocus();
  632.             }
  633.             else if(mx_internal::sourceMenuBar)
  634.             {
  635.                mx_internal::supposedToLoseFocus = true;
  636.                mx_internal::sourceMenuBar.setFocus();
  637.                mx_internal::sourceMenuBar.dispatchEvent(param1);
  638.             }
  639.             param1.stopPropagation();
  640.          }
  641.          else if(param1.keyCode == Keyboard.ENTER || param1.keyCode == Keyboard.SPACE)
  642.          {
  643.             if(Boolean(_loc3_) && mx_internal::_dataDescriptor.isBranch(_loc3_))
  644.             {
  645.                mx_internal::openSubMenu(_loc2_);
  646.                _loc4_ = IMenuItemRenderer(_loc2_).menu;
  647.                mx_internal::supposedToLoseFocus = true;
  648.                _loc4_.setFocus();
  649.                _loc4_.moveSelBy(-1,1);
  650.             }
  651.             else if(_loc3_)
  652.             {
  653.                setMenuItemToggled(_loc3_,!mx_internal::_dataDescriptor.isToggled(_loc3_));
  654.                _loc5_ = new MenuEvent(MenuEvent.ITEM_CLICK);
  655.                _loc5_.menu = this;
  656.                _loc5_.index = this.selectedIndex;
  657.                _loc5_.menuBar = mx_internal::sourceMenuBar;
  658.                _loc5_.label = itemToLabel(_loc3_);
  659.                _loc5_.item = _loc3_;
  660.                _loc5_.itemRenderer = _loc2_;
  661.                mx_internal::getRootMenu().dispatchEvent(_loc5_);
  662.                _loc5_ = new MenuEvent(MenuEvent.CHANGE);
  663.                _loc5_.menu = this;
  664.                _loc5_.index = this.selectedIndex;
  665.                _loc5_.menuBar = mx_internal::sourceMenuBar;
  666.                _loc5_.label = itemToLabel(_loc3_);
  667.                _loc5_.item = _loc3_;
  668.                _loc5_.itemRenderer = _loc2_;
  669.                mx_internal::getRootMenu().dispatchEvent(_loc5_);
  670.                mx_internal::hideAllMenus();
  671.             }
  672.             param1.stopPropagation();
  673.          }
  674.          else if(param1.keyCode == Keyboard.TAB)
  675.          {
  676.             _loc5_ = new MenuEvent(MenuEvent.MENU_HIDE);
  677.             _loc5_.menu = mx_internal::getRootMenu();
  678.             _loc5_.menuBar = mx_internal::sourceMenuBar;
  679.             mx_internal::getRootMenu().dispatchEvent(_loc5_);
  680.             mx_internal::hideAllMenus();
  681.             param1.stopPropagation();
  682.          }
  683.          else if(param1.keyCode == Keyboard.ESCAPE)
  684.          {
  685.             if(mx_internal::_parentMenu)
  686.             {
  687.                mx_internal::supposedToLoseFocus = true;
  688.                hide();
  689.                mx_internal::_parentMenu.setFocus();
  690.             }
  691.             else
  692.             {
  693.                _loc5_ = new MenuEvent(MenuEvent.MENU_HIDE);
  694.                _loc5_.menu = mx_internal::getRootMenu();
  695.                _loc5_.menuBar = mx_internal::sourceMenuBar;
  696.                mx_internal::getRootMenu().dispatchEvent(_loc5_);
  697.                mx_internal::hideAllMenus();
  698.                param1.stopPropagation();
  699.             }
  700.          }
  701.       }
  702.       
  703.       private function parentItemRendererHandler(param1:Event) : void
  704.       {
  705.          itemRenderer = parentMenu.itemRenderer;
  706.       }
  707.       
  708.       mx_internal function onTweenEnd(param1:Object) : void
  709.       {
  710.          UIComponent.resumeBackgroundProcessing();
  711.          scrollRect = null;
  712.          mx_internal::popupTween = null;
  713.       }
  714.       
  715.       public function set dataDescriptor(param1:IMenuDataDescriptor) : void
  716.       {
  717.          mx_internal::_dataDescriptor = param1;
  718.       }
  719.       
  720.       override public function set dataProvider(param1:Object) : void
  721.       {
  722.          var _loc2_:XMLList = null;
  723.          var _loc3_:Array = null;
  724.          if(mx_internal::_rootModel)
  725.          {
  726.             mx_internal::_rootModel.removeEventListener(CollectionEvent.COLLECTION_CHANGE,collectionChangeHandler);
  727.          }
  728.          if(typeof param1 == "string")
  729.          {
  730.             param1 = new XML(param1);
  731.          }
  732.          else if(param1 is XMLNode)
  733.          {
  734.             param1 = new XML(XMLNode(param1).toString());
  735.          }
  736.          else if(param1 is XMLList)
  737.          {
  738.             param1 = new XMLListCollection(param1 as XMLList);
  739.          }
  740.          if(param1 is XML)
  741.          {
  742.             mx_internal::_hasRoot = true;
  743.             _loc2_ = new XMLList();
  744.             _loc2_ += param1;
  745.             mx_internal::_rootModel = new XMLListCollection(_loc2_);
  746.          }
  747.          else if(param1 is ICollectionView)
  748.          {
  749.             mx_internal::_rootModel = ICollectionView(param1);
  750.             if(mx_internal::_rootModel.length == 1)
  751.             {
  752.                mx_internal::_hasRoot = true;
  753.             }
  754.          }
  755.          else if(param1 is Array)
  756.          {
  757.             mx_internal::_rootModel = new ArrayCollection(param1 as Array);
  758.          }
  759.          else if(param1 is Object)
  760.          {
  761.             mx_internal::_hasRoot = true;
  762.             _loc3_ = [];
  763.             _loc3_.push(param1);
  764.             mx_internal::_rootModel = new ArrayCollection(_loc3_);
  765.          }
  766.          else
  767.          {
  768.             mx_internal::_rootModel = new ArrayCollection();
  769.          }
  770.          mx_internal::_rootModel.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionChangeHandler,false,0,true);
  771.          mx_internal::dataProviderChanged = true;
  772.          invalidateProperties();
  773.       }
  774.       
  775.       override protected function drawItem(param1:IListItemRenderer, param2:Boolean = false, param3:Boolean = false, param4:Boolean = false, param5:Boolean = false) : void
  776.       {
  777.          if(!getStyle("useRollOver"))
  778.          {
  779.             super.drawItem(param1,param2,false,false,param5);
  780.          }
  781.          else
  782.          {
  783.             super.drawItem(param1,param2,param3,param4,param5);
  784.          }
  785.       }
  786.       
  787.       private function parentLabelFieldHandler(param1:Event) : void
  788.       {
  789.          labelField = parentMenu.labelField;
  790.       }
  791.       
  792.       override protected function collectionChangeHandler(param1:Event) : void
  793.       {
  794.          var _loc2_:CollectionEvent = null;
  795.          if(param1 is CollectionEvent)
  796.          {
  797.             _loc2_ = CollectionEvent(param1);
  798.             if(_loc2_.kind == CollectionEventKind.ADD)
  799.             {
  800.                super.collectionChangeHandler(param1);
  801.                mx_internal::dataProviderChanged = true;
  802.                invalidateSize();
  803.                UIComponentGlobals.mx_internal::layoutManager.validateClient(this);
  804.                setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight());
  805.             }
  806.             else if(_loc2_.kind == CollectionEventKind.REMOVE)
  807.             {
  808.                super.collectionChangeHandler(param1);
  809.                mx_internal::dataProviderChanged = true;
  810.                invalidateSize();
  811.                UIComponentGlobals.mx_internal::layoutManager.validateClient(this);
  812.                setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight());
  813.             }
  814.             else if(_loc2_.kind == CollectionEventKind.REFRESH)
  815.             {
  816.                invalidateSize();
  817.                invalidateProperties();
  818.             }
  819.             else if(_loc2_.kind == CollectionEventKind.RESET)
  820.             {
  821.                invalidateSize();
  822.                invalidateProperties();
  823.             }
  824.          }
  825.          itemsSizeChanged = true;
  826.          invalidateDisplayList();
  827.       }
  828.       
  829.       override protected function makeListData(param1:Object, param2:String, param3:int) : BaseListData
  830.       {
  831.          var _loc4_:MenuListData = new MenuListData(itemToLabel(param1),itemToIcon(param1),labelField,param2,this,param3);
  832.          _loc4_.maxMeasuredIconWidth = maxMeasuredIconWidth;
  833.          _loc4_.maxMeasuredTypeIconWidth = maxMeasuredTypeIconWidth;
  834.          _loc4_.maxMeasuredBranchIconWidth = maxMeasuredBranchIconWidth;
  835.          _loc4_.useTwoColumns = useTwoColumns;
  836.          return _loc4_;
  837.       }
  838.       
  839.       public function get showRoot() : Boolean
  840.       {
  841.          return mx_internal::_showRoot;
  842.       }
  843.       
  844.       private function parentLabelFunctionHandler(param1:Event) : void
  845.       {
  846.          labelFunction = parentMenu.labelFunction;
  847.       }
  848.       
  849.       private function getRowIndex(param1:IListItemRenderer) : int
  850.       {
  851.          var _loc3_:IListItemRenderer = null;
  852.          var _loc2_:int = 0;
  853.          while(_loc2_ < listItems.length)
  854.          {
  855.             _loc3_ = listItems[_loc2_][0];
  856.             if(_loc3_ && _loc3_.data && mx_internal::_dataDescriptor.getType(_loc3_.data) != "separator")
  857.             {
  858.                if(_loc3_ == param1)
  859.                {
  860.                   return _loc2_;
  861.                }
  862.             }
  863.             _loc2_++;
  864.          }
  865.          return -1;
  866.       }
  867.       
  868.       private function parentIconFunctionHandler(param1:Event) : void
  869.       {
  870.          iconFunction = parentMenu.iconFunction;
  871.       }
  872.       
  873.       mx_internal function get subMenus() : Array
  874.       {
  875.          var _loc1_:Array = [];
  876.          var _loc2_:int = 0;
  877.          while(_loc2_ < listItems.length)
  878.          {
  879.             _loc1_.push(listItems[_loc2_][0].menu);
  880.             _loc2_++;
  881.          }
  882.          return _loc1_;
  883.       }
  884.       
  885.       override public function setFocus() : void
  886.       {
  887.          super.setFocus();
  888.       }
  889.       
  890.       public function get hasRoot() : Boolean
  891.       {
  892.          return mx_internal::_hasRoot;
  893.       }
  894.       
  895.       private function parentHideHandler(param1:FlexEvent) : void
  896.       {
  897.          visible = false;
  898.       }
  899.       
  900.       override protected function initializeAccessibility() : void
  901.       {
  902.          if(mx_internal::createAccessibilityImplementation != null)
  903.          {
  904.             mx_internal::createAccessibilityImplementation(this);
  905.          }
  906.       }
  907.       
  908.       private function closeSubMenu(param1:Menu) : void
  909.       {
  910.          param1.hide();
  911.          clearInterval(param1.mx_internal::closeTimer);
  912.          param1.mx_internal::closeTimer = 0;
  913.       }
  914.       
  915.       override protected function mouseOutHandler(param1:MouseEvent) : void
  916.       {
  917.          var _loc3_:Object = null;
  918.          if(!enabled || !selectable || !visible)
  919.          {
  920.             return;
  921.          }
  922.          systemManager.removeEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  923.          var _loc2_:IListItemRenderer = mouseEventToItemRenderer(param1);
  924.          if(!_loc2_)
  925.          {
  926.             return;
  927.          }
  928.          if(Boolean(_loc2_) && Boolean(_loc2_.data))
  929.          {
  930.             _loc3_ = _loc2_.data;
  931.          }
  932.          if(mx_internal::openSubMenuTimer)
  933.          {
  934.             clearInterval(mx_internal::openSubMenuTimer);
  935.             mx_internal::openSubMenuTimer = 0;
  936.          }
  937.          if(itemRendererContains(_loc2_,param1.relatedObject) || itemRendererContains(_loc2_,DisplayObject(param1.target)) || param1.relatedObject == highlightIndicator || param1.relatedObject == listContent || !highlightItemRenderer)
  938.          {
  939.             return;
  940.          }
  941.          if(getStyle("useRollOver") && Boolean(_loc3_))
  942.          {
  943.             mx_internal::clearHighlight(_loc2_);
  944.          }
  945.       }
  946.       
  947.       override public function get horizontalScrollPolicy() : String
  948.       {
  949.          return ScrollPolicy.OFF;
  950.       }
  951.       
  952.       private function mouseDownOutsideHandler(param1:Event) : void
  953.       {
  954.          var _loc2_:MouseEvent = null;
  955.          if(param1 is MouseEvent)
  956.          {
  957.             _loc2_ = MouseEvent(param1);
  958.             if(!isMouseOverMenu(_loc2_) && !isMouseOverMenuBarItem(_loc2_))
  959.             {
  960.                mx_internal::hideAllMenus();
  961.             }
  962.          }
  963.          else if(param1 is SandboxMouseEvent)
  964.          {
  965.             mx_internal::hideAllMenus();
  966.          }
  967.       }
  968.       
  969.       override protected function configureScrollBars() : void
  970.       {
  971.       }
  972.       
  973.       public function get dataDescriptor() : IMenuDataDescriptor
  974.       {
  975.          return IMenuDataDescriptor(mx_internal::_dataDescriptor);
  976.       }
  977.       
  978.       override public function get dataProvider() : Object
  979.       {
  980.          var _loc1_:* = super.dataProvider;
  981.          if(_loc1_ == null)
  982.          {
  983.             if(mx_internal::_rootModel != null)
  984.             {
  985.                return mx_internal::_rootModel;
  986.             }
  987.             return null;
  988.          }
  989.          return _loc1_;
  990.       }
  991.       
  992.       override public function styleChanged(param1:String) : void
  993.       {
  994.          super.styleChanged(param1);
  995.          mx_internal::deleteDependentSubMenus();
  996.       }
  997.       
  998.       mx_internal function onTweenUpdate(param1:Object) : void
  999.       {
  1000.          scrollRect = new Rectangle(0,0,param1[0],param1[1]);
  1001.       }
  1002.       
  1003.       override protected function commitProperties() : void
  1004.       {
  1005.          var _loc1_:ICollectionView = null;
  1006.          var _loc2_:* = undefined;
  1007.          if(mx_internal::showRootChanged)
  1008.          {
  1009.             if(!mx_internal::_hasRoot)
  1010.             {
  1011.                mx_internal::showRootChanged = false;
  1012.             }
  1013.          }
  1014.          if(mx_internal::dataProviderChanged || mx_internal::showRootChanged)
  1015.          {
  1016.             mx_internal::dataProviderChanged = false;
  1017.             mx_internal::showRootChanged = false;
  1018.             if(mx_internal::_rootModel && !mx_internal::_showRoot && mx_internal::_hasRoot)
  1019.             {
  1020.                _loc2_ = mx_internal::_rootModel.createCursor().current;
  1021.                if(_loc2_ != null && mx_internal::_dataDescriptor.isBranch(_loc2_,mx_internal::_rootModel) && mx_internal::_dataDescriptor.hasChildren(_loc2_,mx_internal::_rootModel))
  1022.                {
  1023.                   _loc1_ = mx_internal::_dataDescriptor.getChildren(_loc2_,mx_internal::_rootModel);
  1024.                }
  1025.             }
  1026.             if(mx_internal::_rootModel)
  1027.             {
  1028.                if(!_loc1_)
  1029.                {
  1030.                   _loc1_ = mx_internal::_rootModel;
  1031.                }
  1032.                super.dataProvider = _loc1_;
  1033.                _loc1_.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionChangeHandler,false,EventPriority.DEFAULT_HANDLER,true);
  1034.             }
  1035.             else
  1036.             {
  1037.                super.dataProvider = null;
  1038.             }
  1039.          }
  1040.          super.commitProperties();
  1041.       }
  1042.       
  1043.       private function parentIconFieldHandler(param1:Event) : void
  1044.       {
  1045.          iconField = parentMenu.iconField;
  1046.       }
  1047.       
  1048.       mx_internal function getRootMenu() : Menu
  1049.       {
  1050.          var _loc1_:Menu = this;
  1051.          while(_loc1_.parentMenu)
  1052.          {
  1053.             _loc1_ = _loc1_.parentMenu;
  1054.          }
  1055.          return _loc1_;
  1056.       }
  1057.       
  1058.       override mx_internal function clearHighlight(param1:IListItemRenderer) : void
  1059.       {
  1060.          var _loc4_:MenuEvent = null;
  1061.          var _loc2_:String = itemToUID(param1.data);
  1062.          drawItem(visibleData[_loc2_],isItemSelected(param1.data),false,_loc2_ == caretUID);
  1063.          var _loc3_:Point = itemRendererToIndices(param1);
  1064.          if(_loc3_)
  1065.          {
  1066.             _loc4_ = new MenuEvent(MenuEvent.ITEM_ROLL_OUT);
  1067.             _loc4_.menu = this;
  1068.             _loc4_.index = getRowIndex(param1);
  1069.             _loc4_.menuBar = mx_internal::sourceMenuBar;
  1070.             _loc4_.label = itemToLabel(param1.data);
  1071.             _loc4_.item = param1.data;
  1072.             _loc4_.itemRenderer = param1;
  1073.             mx_internal::getRootMenu().dispatchEvent(_loc4_);
  1074.          }
  1075.       }
  1076.       
  1077.       override public function set verticalScrollPolicy(param1:String) : void
  1078.       {
  1079.       }
  1080.       
  1081.       override protected function mouseClickHandler(param1:MouseEvent) : void
  1082.       {
  1083.       }
  1084.       
  1085.       private function isMouseOverMenuBarItem(param1:MouseEvent) : Boolean
  1086.       {
  1087.          if(!mx_internal::sourceMenuBarItem)
  1088.          {
  1089.             return false;
  1090.          }
  1091.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  1092.          while(_loc2_)
  1093.          {
  1094.             if(_loc2_ == mx_internal::sourceMenuBarItem)
  1095.             {
  1096.                return true;
  1097.             }
  1098.             _loc2_ = _loc2_.parent;
  1099.          }
  1100.          return false;
  1101.       }
  1102.       
  1103.       override protected function mouseOverHandler(param1:MouseEvent) : void
  1104.       {
  1105.          var row:IListItemRenderer;
  1106.          var item:Object = null;
  1107.          var menuEvent:MenuEvent = null;
  1108.          var event:MouseEvent = param1;
  1109.          if(!enabled || !selectable || !visible)
  1110.          {
  1111.             return;
  1112.          }
  1113.          systemManager.addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true,0,true);
  1114.          row = mouseEventToItemRenderer(event);
  1115.          if(!row)
  1116.          {
  1117.             return;
  1118.          }
  1119.          if(Boolean(row) && Boolean(row.data))
  1120.          {
  1121.             item = row.data;
  1122.          }
  1123.          if(Boolean(row) && row != anchorRow)
  1124.          {
  1125.             if(anchorRow)
  1126.             {
  1127.                drawItem(anchorRow,false,false);
  1128.             }
  1129.             if(subMenu)
  1130.             {
  1131.                subMenu.mx_internal::supposedToLoseFocus = true;
  1132.                subMenu.mx_internal::closeTimer = setTimeout(closeSubMenu,250,subMenu);
  1133.             }
  1134.             subMenu = null;
  1135.             anchorRow = null;
  1136.          }
  1137.          else if(Boolean(subMenu) && Boolean(subMenu.subMenu))
  1138.          {
  1139.             subMenu.subMenu.hide();
  1140.          }
  1141.          if(mx_internal::_dataDescriptor.isBranch(item) && mx_internal::_dataDescriptor.isEnabled(item))
  1142.          {
  1143.             anchorRow = row;
  1144.             if(Boolean(subMenu) && Boolean(subMenu.mx_internal::closeTimer))
  1145.             {
  1146.                clearInterval(subMenu.mx_internal::closeTimer);
  1147.                subMenu.mx_internal::closeTimer = 0;
  1148.             }
  1149.             if(!subMenu || !subMenu.visible)
  1150.             {
  1151.                if(mx_internal::openSubMenuTimer)
  1152.                {
  1153.                   clearInterval(mx_internal::openSubMenuTimer);
  1154.                }
  1155.                mx_internal::openSubMenuTimer = setTimeout(function(param1:IListItemRenderer):void
  1156.                {
  1157.                   mx_internal::openSubMenu(param1);
  1158.                },250,row);
  1159.             }
  1160.          }
  1161.          if(Boolean(item) && mx_internal::_dataDescriptor.isEnabled(item))
  1162.          {
  1163.             if(event.relatedObject)
  1164.             {
  1165.                if(itemRendererContains(row,event.relatedObject) || row == mx_internal::lastHighlightItemRenderer || event.relatedObject == highlightIndicator)
  1166.                {
  1167.                   return;
  1168.                }
  1169.             }
  1170.          }
  1171.          if(row)
  1172.          {
  1173.             drawItem(row,false,Boolean(item && mx_internal::_dataDescriptor.isEnabled(item)));
  1174.             if(Boolean(item) && mx_internal::_dataDescriptor.isEnabled(item))
  1175.             {
  1176.                menuEvent = new MenuEvent(MenuEvent.ITEM_ROLL_OVER);
  1177.                menuEvent.menu = this;
  1178.                menuEvent.index = getRowIndex(row);
  1179.                menuEvent.menuBar = mx_internal::sourceMenuBar;
  1180.                menuEvent.label = itemToLabel(item);
  1181.                menuEvent.item = item;
  1182.                menuEvent.itemRenderer = row;
  1183.                mx_internal::getRootMenu().dispatchEvent(menuEvent);
  1184.             }
  1185.          }
  1186.       }
  1187.       
  1188.       override public function get verticalScrollPolicy() : String
  1189.       {
  1190.          return ScrollPolicy.OFF;
  1191.       }
  1192.       
  1193.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  1194.       {
  1195.          super.updateDisplayList(param1,param2);
  1196.          border.move(0,0);
  1197.          border.visible = dataProvider != null && dataProvider.length > 0;
  1198.          if(hiddenItem)
  1199.          {
  1200.             hiddenItem.setActualSize(param1,hiddenItem.getExplicitOrMeasuredHeight());
  1201.          }
  1202.       }
  1203.       
  1204.       public function show(param1:Object = null, param2:Object = null) : void
  1205.       {
  1206.          var _loc7_:Rectangle = null;
  1207.          var _loc8_:Point = null;
  1208.          var _loc9_:Number = NaN;
  1209.          var _loc10_:InterManagerRequest = null;
  1210.          if(Boolean(collection) && collection.length == 0)
  1211.          {
  1212.             return;
  1213.          }
  1214.          if(Boolean(parentMenu) && !parentMenu.visible)
  1215.          {
  1216.             return;
  1217.          }
  1218.          if(visible)
  1219.          {
  1220.             return;
  1221.          }
  1222.          if(Boolean(mx_internal::parentDisplayObject) && parent != mx_internal::parentDisplayObject)
  1223.          {
  1224.             PopUpManager.addPopUp(this,mx_internal::parentDisplayObject,false);
  1225.             addEventListener(MenuEvent.MENU_HIDE,menuHideHandler,false,EventPriority.DEFAULT_HANDLER);
  1226.          }
  1227.          var _loc3_:MenuEvent = new MenuEvent(MenuEvent.MENU_SHOW);
  1228.          _loc3_.menu = this;
  1229.          _loc3_.menuBar = mx_internal::sourceMenuBar;
  1230.          mx_internal::getRootMenu().dispatchEvent(_loc3_);
  1231.          systemManager.activate(this);
  1232.          if(param1 !== null && !isNaN(Number(param1)))
  1233.          {
  1234.             x = Number(param1);
  1235.          }
  1236.          if(param2 !== null && !isNaN(Number(param2)))
  1237.          {
  1238.             y = Number(param2);
  1239.          }
  1240.          var _loc4_:ISystemManager = systemManager.topLevelSystemManager;
  1241.          var _loc5_:DisplayObject = _loc4_.getSandboxRoot();
  1242.          if(this != mx_internal::getRootMenu())
  1243.          {
  1244.             _loc8_ = new Point(x,y);
  1245.             _loc8_ = _loc5_.localToGlobal(_loc8_);
  1246.             if(_loc4_ != _loc5_)
  1247.             {
  1248.                _loc10_ = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST,false,false,"getVisibleApplicationRect");
  1249.                _loc5_.dispatchEvent(_loc10_);
  1250.                _loc7_ = Rectangle(_loc10_.value);
  1251.             }
  1252.             else
  1253.             {
  1254.                _loc7_ = _loc4_.getVisibleApplicationRect();
  1255.             }
  1256.             _loc9_ = _loc8_.x + width - _loc7_.right;
  1257.             if(_loc9_ > 0)
  1258.             {
  1259.                x = Math.max(x - _loc9_,0);
  1260.             }
  1261.             _loc9_ = _loc8_.y + height - _loc7_.bottom;
  1262.             if(_loc9_ > 0)
  1263.             {
  1264.                y = Math.max(y - _loc9_,0);
  1265.             }
  1266.          }
  1267.          UIComponentGlobals.mx_internal::layoutManager.validateClient(this,true);
  1268.          setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight());
  1269.          cacheAsBitmap = true;
  1270.          var _loc6_:Number = getStyle("openDuration");
  1271.          if(_loc6_ != 0)
  1272.          {
  1273.             scrollRect = new Rectangle(0,0,unscaledWidth,0);
  1274.             visible = true;
  1275.             UIComponentGlobals.mx_internal::layoutManager.validateNow();
  1276.             UIComponent.suspendBackgroundProcessing();
  1277.             mx_internal::popupTween = new Tween(this,[0,0],[unscaledWidth,unscaledHeight],_loc6_);
  1278.          }
  1279.          else
  1280.          {
  1281.             UIComponentGlobals.mx_internal::layoutManager.validateNow();
  1282.             visible = true;
  1283.          }
  1284.          focusManager.setFocus(this);
  1285.          mx_internal::supposedToLoseFocus = true;
  1286.          _loc5_.addEventListener(MouseEvent.MOUSE_DOWN,mouseDownOutsideHandler,false,0,true);
  1287.          addEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,mouseDownOutsideHandler,false,0,true);
  1288.       }
  1289.       
  1290.       public function set showRoot(param1:Boolean) : void
  1291.       {
  1292.          if(mx_internal::_showRoot != param1)
  1293.          {
  1294.             mx_internal::_showRoot = param1;
  1295.             mx_internal::showRootChanged = true;
  1296.             invalidateProperties();
  1297.          }
  1298.       }
  1299.    }
  1300. }
  1301.  
  1302.